/**
 * API客户端模块
 * 提供统一的API请求接口，支持请求拦截、响应拦截、错误处理等功能
 */

export class ApiClient {
    constructor(baseURL, options = {}) {
        this.baseURL = baseURL || '/api';
        this.defaultHeaders = {
            'Content-Type': 'application/json',
            ...options.headers
        };
        this.interceptors = {
            request: [],
            response: [],
            error: []
        };
        this.timeout = options.timeout || 10000;
        
        // 初始化认证令牌
        this.authToken = localStorage.getItem('authToken') || null;
    }

    /**
     * 发送API请求
     * @param {string} endpoint - API端点
     * @param {Object} options - 请求选项
     * @returns {Promise} - 返回Promise对象
     */
    async request(endpoint, options = {}) {
        const url = `${this.baseURL}${endpoint}`;
        const config = {
            headers: { ...this.defaultHeaders, ...options.headers },
            ...options
        };

        // 添加认证令牌
        if (this.authToken) {
            config.headers.Authorization = `Bearer ${this.authToken}`;
        }

        // 设置超时
        const controller = new AbortController();
        config.signal = controller.signal;
        
        const timeoutId = setTimeout(() => {
            controller.abort();
        }, this.timeout);

        try {
            // 执行请求拦截器
            for (const interceptor of this.interceptors.request) {
                await interceptor(config);
            }

            // 发送请求
            const response = await fetch(url, config);
            clearTimeout(timeoutId);

            // 检查响应状态
            if (!response.ok) {
                const error = new Error(`HTTP error! status: ${response.status}`);
                error.status = response.status;
                error.statusText = response.statusText;
                
                // 尝试解析错误响应
                try {
                    const errorData = await response.json();
                    error.data = errorData;
                } catch (e) {
                    // 忽略JSON解析错误
                }
                
                throw error;
            }

            // 解析响应数据
            const data = await response.json();
            
            // 执行响应拦截器
            for (const interceptor of this.interceptors.response) {
                await interceptor(data, response);
            }

            return data;
        } catch (error) {
            clearTimeout(timeoutId);
            
            // 执行错误拦截器
            for (const interceptor of this.interceptors.error) {
                await interceptor(error);
            }
            
            throw error;
        }
    }

    /**
     * GET请求
     * @param {string} endpoint - API端点
     * @param {Object} params - 查询参数
     * @param {Object} options - 请求选项
     * @returns {Promise} - 返回Promise对象
     */
    async get(endpoint, params = {}, options = {}) {
        const url = new URL(`${this.baseURL}${endpoint}`, window.location.origin);
        
        // 添加查询参数
        Object.keys(params).forEach(key => {
            if (params[key] !== undefined && params[key] !== null) {
                url.searchParams.append(key, params[key]);
            }
        });

        return this.request(url.pathname + url.search, {
            method: 'GET',
            ...options
        });
    }

    /**
     * POST请求
     * @param {string} endpoint - API端点
     * @param {Object} data - 请求数据
     * @param {Object} options - 请求选项
     * @returns {Promise} - 返回Promise对象
     */
    async post(endpoint, data = {}, options = {}) {
        return this.request(endpoint, {
            method: 'POST',
            body: JSON.stringify(data),
            ...options
        });
    }

    /**
     * PUT请求
     * @param {string} endpoint - API端点
     * @param {Object} data - 请求数据
     * @param {Object} options - 请求选项
     * @returns {Promise} - 返回Promise对象
     */
    async put(endpoint, data = {}, options = {}) {
        return this.request(endpoint, {
            method: 'PUT',
            body: JSON.stringify(data),
            ...options
        });
    }

    /**
     * DELETE请求
     * @param {string} endpoint - API端点
     * @param {Object} options - 请求选项
     * @returns {Promise} - 返回Promise对象
     */
    async delete(endpoint, options = {}) {
        return this.request(endpoint, {
            method: 'DELETE',
            ...options
        });
    }

    /**
     * 上传文件
     * @param {string} endpoint - API端点
     * @param {FormData} formData - 表单数据
     * @param {Object} options - 请求选项
     * @returns {Promise} - 返回Promise对象
     */
    async upload(endpoint, formData, options = {}) {
        // 移除Content-Type，让浏览器自动设置multipart/form-data边界
        const headers = { ...options.headers };
        delete headers['Content-Type'];

        return this.request(endpoint, {
            method: 'POST',
            body: formData,
            headers,
            ...options
        });
    }

    /**
     * 添加请求拦截器
     * @param {Function} interceptor - 拦截器函数
     */
    addRequestInterceptor(interceptor) {
        this.interceptors.request.push(interceptor);
    }

    /**
     * 添加响应拦截器
     * @param {Function} interceptor - 拦截器函数
     */
    addResponseInterceptor(interceptor) {
        this.interceptors.response.push(interceptor);
    }

    /**
     * 添加错误拦截器
     * @param {Function} interceptor - 拦截器函数
     */
    addErrorInterceptor(interceptor) {
        this.interceptors.error.push(interceptor);
    }

    /**
     * 设置认证令牌
     * @param {string} token - 认证令牌
     */
    setAuthToken(token) {
        this.authToken = token;
        if (token) {
            localStorage.setItem('authToken', token);
        } else {
            localStorage.removeItem('authToken');
        }
    }

    /**
     * 获取认证令牌
     * @returns {string} - 认证令牌
     */
    getAuthToken() {
        return this.authToken;
    }

    /**
     * 清除认证令牌
     */
    clearAuthToken() {
        this.authToken = null;
        localStorage.removeItem('authToken');
    }

    /**
     * 设置默认请求头
     * @param {Object} headers - 请求头
     */
    setDefaultHeaders(headers) {
        this.defaultHeaders = { ...this.defaultHeaders, ...headers };
    }

    /**
     * 设置超时时间
     * @param {number} timeout - 超时时间（毫秒）
     */
    setTimeout(timeout) {
        this.timeout = timeout;
    }
}

// 创建默认API客户端实例
export const apiClient = new ApiClient();

// 添加默认请求拦截器
apiClient.addRequestInterceptor(async (config) => {
    // 添加请求ID
    config.headers['X-Request-ID'] = generateRequestId();
    
    // 添加时间戳
    config.headers['X-Request-Time'] = Date.now();
    
    console.log(`[API Request] ${config.method} ${config.url}`, config.body);
});

// 添加默认响应拦截器
apiClient.addResponseInterceptor(async (data, response) => {
    console.log(`[API Response] ${response.status} ${response.url}`, data);
});

// 添加默认错误拦截器
apiClient.addErrorInterceptor(async (error) => {
    console.error(`[API Error] ${error.status} ${error.message}`, error.data);
    
    // 处理认证错误
    if (error.status === 401) {
        // 清除认证令牌
        apiClient.clearAuthToken();
        
        // 重定向到登录页面
        if (window.location.pathname !== '/login.html') {
            window.location.href = '/login.html';
        }
    }
    
    // 处理服务器错误
    if (error.status >= 500) {
        // 显示错误通知
        showNotification('服务器错误，请稍后重试', 'error');
    }
});

/**
 * 生成请求ID
 * @returns {string} - 请求ID
 */
function generateRequestId() {
    return `req_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
}

/**
 * 显示通知
 * @param {string} message - 通知消息
 * @param {string} type - 通知类型
 */
function showNotification(message, type = 'info') {
    // 这里可以集成具体的通知库，如Toastify、Notyf等
    console.log(`[${type.toUpperCase()}] ${message}`);
    
    // 简单的DOM通知实现
    const notification = document.createElement('div');
    notification.className = `notification notification-${type}`;
    notification.textContent = message;
    
    document.body.appendChild(notification);
    
    // 自动移除通知
    setTimeout(() => {
        if (notification.parentNode) {
            notification.parentNode.removeChild(notification);
        }
    }, 5000);
}

// 导出默认API客户端
export default apiClient;